CRC.c

Go to the documentation of this file.

#include "derivative.h"
#include "CRC.h"
#include "EDMA.h"
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
static const uint8_t cau8CRCConfigs[] =
{
  /* CRC32 has been tested and validated */
  /* CRC_CCITT hasn't */
  (CRC_INSTANCE_0_MASK | CRC_CCITT | CRC_NO_MSB_SWAP | CRC_NO_RESULT_INV),
  (CRC_INSTANCE_1_MASK | CRC_CCITT | CRC_NO_MSB_SWAP | CRC_NO_RESULT_INV),
  (CRC_INSTANCE_0_MASK | CRC_32 | CRC_MSB_SWAP | CRC_RESULT_INV),
  (CRC_INSTANCE_1_MASK | CRC_32 | CRC_MSB_SWAP | CRC_RESULT_INV) };
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
static vuint32_t* gpau32CRCResults[2u];
/*
 ******************************************************************************
 * vfnInitCRC
 ******************************************************************************
 */
void vfnInitCRC(uint8_t u8Instance, uint32_t u32Remainder)
{
  /* Purpose of this fn is ensure that we have nothing going on in a given */
  /* instance */
  /* Limit the number of instances to the possible HW combinations. In this */
  /* case, this means two. */
  u8Instance = (u8Instance > CLEAR);
  
  /* Make sure that the global pointer to the result is empty */
  gpau32CRCResults[u8Instance] = (uint32_t*)CLEAR;
  
  /* Make sure that the instance contains no data */
  CRC.CNTX[u8Instance].CRC_INP.W = CLEAR;
  CRC.CNTX[u8Instance].CRC_CSTAT.W = u32Remainder;
  
  return;
}
/*
 ******************************************************************************
 * u8fnCRC
 ******************************************************************************
 */
uint8_t u8fnCRC(const uint8_t* pu8StartAddress,
                const uint32_t u32NOfBytes,
                uint32_t* pu32Result,
                const uint32_t u32Remainder,
                const uint8_t u8DMAChannel,
                const uint8_t u8CRCConfig)
{
  uint8_t u8Status;
  CRCConfig_t tCRCConfig;
  
  u8Status = u8fnDMAPending(u8DMAChannel);
  tCRCConfig = *(CRCConfig_t*)&(cau8CRCConfigs[u8CRCConfig]);
  
  if(CLEAR == u8Status)
  {
    /* Reset CRC channel */
    vfnInitCRC(tCRCConfig.P.Instance, u32Remainder);
    
    /* Configure a DMA channel for this operation */
    vfnCRCConfigDMA(pu8StartAddress, u32NOfBytes, u8DMAChannel, tCRCConfig);
    
    /* Configure CRC. */
    vfnCRCConfig(*(CRCConfig_t*)&(cau8CRCConfigs[u8CRCConfig]));
    
    /* Remember pointer */
    gpau32CRCResults[tCRCConfig.P.Instance] = pu32Result;
    
    /* Start */
    vfnDMAStart(u8DMAChannel);
  }
  else
  {
    /* Return status */
  }
  return;
}
/*
 ******************************************************************************
 * vfnCRCConfig
 ******************************************************************************
 */
static void vfnCRCConfig(CRCConfig_t tConfig)
{
  CRC.CNTX[tConfig.P.Instance].CRC_CFG.W = (uint32_t)(tConfig.A & 0x0Fu);
  
  return;
}
/*
 ******************************************************************************
 * vfnCRCConfigDMA
 ******************************************************************************
 */
static void vfnCRCConfigDMA(const uint8_t* pu8StartAddress,
                            const uint32_t u32NOfBytes,
                            const uint8_t u8DMAChannel,
                            const CRCConfig_t tCRCConfig)
{
  
  TCD_t tMyDefaultConfig;
  
  
  /* Source address is the start address for our CRC */
  tMyDefaultConfig.P.SADDR = (uint32_t)pu8StartAddress;
  /* Destination address is our CRC module input */
  tMyDefaultConfig.P.DADDR
      = (uint32_t)(&(CRC.CNTX[tCRCConfig.P.Instance].CRC_INP.B));
  /* Modulus is 0 */
  tMyDefaultConfig.P.SMOD = CLEAR;
  tMyDefaultConfig.P.DMOD = CLEAR;
  /* We will transfer 32-bit words */
  tMyDefaultConfig.P.SSIZE = DMA_SIZE_8_BIT;
  tMyDefaultConfig.P.DSIZE = DMA_SIZE_8_BIT;
  tMyDefaultConfig.P.SOFF = 1u; /* Offset per minor loop (in bytes) */
  tMyDefaultConfig.P.DOFF = 0u; /* Destination offset per minor loop */
  tMyDefaultConfig.P.NBYTES = u32NOfBytes; /* Inner loop transfer count (in bytes) */
  tMyDefaultConfig.P.SLAST = CLEAR;
  tMyDefaultConfig.P.CITERE_LINK = CLEAR;
  tMyDefaultConfig.P.BITERE_LINK = CLEAR;
  tMyDefaultConfig.P.CITER = 1u; /* Times we will execute the major loop */
  tMyDefaultConfig.P.BITER = 1u; /* Memory for the loop */
  tMyDefaultConfig.P.D_REQ = TRUE; /* Clear HW Start requests after major loop is done */
  
  tMyDefaultConfig.P.DLAST_SGA = CLEAR; /* Last destination offset */
  tMyDefaultConfig.P.MAJORLINKCH = CLEAR;
  tMyDefaultConfig.P.BWC = DMA_BWC_4_CYCLE_STALL;
  tMyDefaultConfig.P.MAJORE_LINK = CLEAR; /* Disable ch2ch linking */
  tMyDefaultConfig.P.E_SG = CLEAR;
  
  tMyDefaultConfig.P.INT_HALF = CLEAR;
  tMyDefaultConfig.P.INT_MAJ = TRUE;
  tMyDefaultConfig.P.START = CLEAR;
  
  vfnDMAConfig(&tMyDefaultConfig, u8DMAChannel);
  
  return;
}
/*
 ******************************************************************************
 * vfnCRCIsr
 ******************************************************************************
 */
static void vfnCRCIsr(uint8_t u8Instance)
{
  *gpau32CRCResults[u8Instance] = CRC.CNTX[u8Instance].CRC_OUTP.W;
  
  return;
}
/*
 ******************************************************************************
 * vfnCRC0Isr
 ******************************************************************************
 */
void vfnCRC0Isr(void)
{
  DMA_CLEAR_ISR_FLAG(CRC_DMA_CH_0);
  EDMA.TCD[CRC_DMA_CH_1].DONE = TRUE;
  vfnCRCIsr(CRC_INSTANCE_0);
  
  return;
}
/*
 ******************************************************************************
 * vfnCRC1Isr
 ******************************************************************************
 */
void vfnCRC1Isr(void)
{
  DMA_CLEAR_ISR_FLAG(CRC_DMA_CH_1);
  EDMA.TCD[CRC_DMA_CH_1].DONE = CLEAR;
  vfnCRCIsr(CRC_INSTANCE_1);
  
  return;
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */